home *** CD-ROM | disk | FTP | other *** search
/ BBS Toolkit / BBS Toolkit.iso / doors_1 / gbs2bbs.zip / ANS2OANS.C next >
C/C++ Source or Header  |  1993-01-04  |  16KB  |  397 lines
  1. /* Version 1.2 modified on  1-Nov-1987 by George A. Stanislav   */
  2. /* Version 1.1 modified on 21-Oct-1987 by George A. Stanislav    */
  3. /*                                */
  4. /*    Original by Wynn Wagner III                */
  5.  
  6. #ifndef LINT_ARGS
  7. #define LINT_ARGS
  8. #endif
  9.  
  10. #include <stdio.h>
  11. #include <string.h>
  12. #include <io.h>
  13. #include <ctype.h>
  14. #include "legible.h"
  15.  
  16. /*--------------------------------------------------------------------------*/
  17. /* External declarations                                                    */
  18. /*--------------------------------------------------------------------------*/
  19. extern int  errno;
  20.  
  21. /*--------------------------------------------------------------------------*/
  22. /* Global declarations                                                      */
  23. /*--------------------------------------------------------------------------*/
  24. FILE       *source         = NULL;
  25. FILE       *dest           = NULL;
  26. int         ansi_digit[4];
  27.  
  28.  
  29. /*--------------------------------------------------------------------------*/
  30. /* USAGE                                                                    */
  31. /*--------------------------------------------------------------------------*/
  32. void usage()
  33.    begin
  34.       cputs("Converts GBS files into BBS files using Opus optimized video controls.\r\n\n\USAGE: Gbs2Bbs <filename>\r\n\n");
  35.       exit(1);
  36.    end /* usage */
  37.  
  38.  
  39.  
  40. /*--------------------------------------------------------------------------*/
  41. /* CAN'T (do something)                                                     */
  42. /*--------------------------------------------------------------------------*/
  43. void cant( do_what, to_whom )
  44.    char *do_what;
  45.    char *to_whom;
  46.    begin
  47.       char s[100];
  48.  
  49.       sprintf(s, "Can't %s %s", do_what, to_whom );
  50.       perror(s);
  51.  
  52.       if (dest)   fclose(dest);
  53.       if (source) fclose(source);
  54.  
  55.       exit(1);
  56.  
  57.    end /* Can't */
  58.  
  59.  
  60.  
  61. /*--------------------------------------------------------------------------*/
  62. /* MAKE FILE NAME                                                           */
  63. /* Build a new file name (node), but use a different tag.                   */
  64. /*--------------------------------------------------------------------------*/
  65. void make_file_name( node, tag )
  66.    char *node;
  67.    char *tag;
  68.    begin
  69.       register char *sptr;
  70.  
  71.       if ( !(sptr=strchr(node,'.')) )  strcat(node,tag);
  72.       else                             strcpy(sptr,tag);
  73.  
  74.    end /* make file name */
  75.  
  76.  
  77. /*--------------------------------------------------------------------------*/
  78. /* COMMAND                                                                  */
  79. /*--------------------------------------------------------------------------*/
  80. void command(which)
  81.    byte which;
  82.    begin
  83.       int   i;
  84.  
  85.       if (ansi_digit[0]>0)
  86.          begin
  87.             for(i=0; i<ansi_digit[0]; i++)
  88.                begin
  89.                   putc( 0x16, dest );
  90.                   putc( which,dest );
  91.                end
  92.             return;
  93.          end
  94.       putc(0x16, dest);
  95.       putc(which,dest);
  96.    end /* command */
  97.  
  98.  
  99.  
  100. /*--------------------------------------------------------------------------*/
  101. /* COLOR                                                                    */
  102. /*--------------------------------------------------------------------------*/
  103. #define BACKGROUND(x) attribute=(attribute&0x8f)+(x)
  104. #define FOREGROUND(x) attribute=(attribute&0xf8)+(x)
  105.  
  106. void color()
  107.    begin
  108.       register int i;
  109.       register int j;
  110.       int blink = 0;
  111.  
  112.       static byte attribute = 0x07;
  113.  
  114.       for(i=0; i<4; i++)
  115.          switch(ansi_digit[i])
  116.             begin
  117.                case  0: attribute     = 0x07;                  break;
  118.                case  1: if (!(attribute & 0x0f))
  119.                attribute |= 0x0f;
  120.             else
  121.                attribute    |= 0x08;               break;
  122.                case  4: FOREGROUND(0x01);                      break;
  123.                case  5: blink         = 0xffff;               break;
  124.                case  7: attribute     = 0x70;                  break;
  125.  
  126.                case 30: FOREGROUND(0x00);                      break;
  127.                case 31: FOREGROUND(0x04);                      break;
  128.                case 32: FOREGROUND(0x02);                      break;
  129.                case 33: FOREGROUND(0x06);                      break;
  130.                case 34: FOREGROUND(0x01);                      break;
  131.                case 35: FOREGROUND(0x05);                      break;
  132.                case 36: FOREGROUND(0x03);                      break;
  133.                case 37: FOREGROUND(0x07);                      break;
  134.  
  135.                case 40: BACKGROUND(0x00);                      break;
  136.                case 41: BACKGROUND(0x40);                      break;
  137.                case 42: BACKGROUND(0x20);                      break;
  138.                case 43: BACKGROUND(0x60);                      break;
  139.                case 44: BACKGROUND(0x10);                      break;
  140.                case 45: BACKGROUND(0x50);                      break;
  141.                case 46: BACKGROUND(0x30);                      break;
  142.                case 47: BACKGROUND(0x70);                      break;
  143.             end
  144.  
  145.       if ((!blink) || attribute)
  146.     begin
  147.        putc( 0x16,       dest );
  148.        putc( 0x01,       dest );
  149.        putc( 0x10,       dest );
  150.        attribute    |=   0x80  ;
  151.        putc( attribute,  dest );
  152.     end
  153.  
  154.  
  155.       if (blink)
  156.     begin
  157.        ansi_digit[0] = 0xffff;
  158.        command(0x02);
  159.     end
  160.  
  161.    end
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168. /*--------------------------------------------------------------------------*/
  169. /* MAIN                                                                     */
  170. /*--------------------------------------------------------------------------*/
  171. main(argc,argv)
  172.    int   argc;
  173.    char *argv[];
  174.    begin
  175.       register char *sptr;
  176.       register int   i;
  177.  
  178.       char           old_name[80];
  179.       char           new_name[80];
  180.       char           buffer[1024];
  181.  
  182.       int            line;
  183.       int            j;
  184.       int            handle;
  185.  
  186.  
  187.       /*--------------------------------------------------------------------*/
  188.       /* Say Howdy                                                          */
  189.       /*--------------------------------------------------------------------*/
  190.       cputs("Gbs2Bbs [1.2]\r\n");
  191.       if (argc<2) usage();
  192.  
  193.  
  194.       /*--------------------------------------------------------------------*/
  195.       /* Turn the existing file into a BAK                                  */
  196.       /*--------------------------------------------------------------------*/
  197.       strcpy( new_name, argv[1] );
  198.       if (!strchr(new_name,'.')) make_file_name( new_name, ".Bbs" );
  199.  
  200.       strcpy( old_name, new_name );
  201.  
  202.       make_file_name( old_name, ".Bak" );
  203.       unlink( old_name );
  204.  
  205.       if (rename(new_name,old_name)) cant("rename",old_name);
  206.  
  207.  
  208.       /*--------------------------------------------------------------------*/
  209.       /* Setup for the conversion                                           */
  210.       /*--------------------------------------------------------------------*/
  211.       line     =
  212.       errno    = 0;
  213.  
  214.       make_file_name( new_name, ".Bbs" );
  215.  
  216.       source   = fopen( old_name, "rb" );
  217.       if (errno) cant("open",old_name);
  218.  
  219.       dest     = fopen( new_name, "wb" );
  220.       if (errno) cant("create",new_name);
  221.  
  222.  
  223.       /*--------------------------------------------------------------------*/
  224.       /* The conversion                                                     */
  225.       /*--------------------------------------------------------------------*/
  226.       while(!feof(source))
  227.          begin
  228.             sptr     = buffer;
  229.             *sptr    = '\0';
  230.             fgets(sptr,1024,source);
  231.             line++;
  232.  
  233.             while(1)
  234.                begin
  235.                   switch( *sptr )
  236.                       begin
  237.                         default:    /*--------------------------------------*/
  238.                                     /* Check on replicating characters      */
  239.                                     /* (Needs to go down to .ASM badly!)    */
  240.                                     /*--------------------------------------*/
  241.                                     for(i=1; sptr[i]==sptr[0]; i++)
  242.                                        ;
  243.                                     if (i>=5)
  244.                                        begin
  245.                       if (i==26)
  246.                          begin
  247.                         putc( *sptr,dest );
  248.                         i--;
  249.                          end
  250.                                           putc( 0x19, dest ); /* ctrl-Y */
  251.                                           putc( *sptr,dest ); /* value  */
  252.                                           putc( i,    dest ); /* factor */
  253.                                           sptr += i;
  254.                                        end
  255.                                     else
  256.                                        begin
  257.                                           putc(*sptr,dest);
  258.                                           sptr++;
  259.                                        end
  260.  
  261.                                     break;
  262.  
  263.                         case 0x1a:  /*--------------------------------------*/
  264.                                     /* End of the file                      */
  265.                                     /*--------------------------------------*/
  266.                                     goto done;
  267.  
  268.                           case 0:     /*--------------------------------------*/
  269.                                     /* End of this line                     */
  270.                                     /*--------------------------------------*/
  271.                                     goto nxt;
  272.  
  273.                         case 0x1b:  /*--------------------------------------*/
  274.                                     /* Escape (ANSI)                        */
  275.                                     /*--------------------------------------*/
  276.                                     for(i=0; i<4; i++)
  277.                                        ansi_digit[i] = 0xffff;
  278.  
  279.                                     i  = 0;
  280.  
  281.                                     sptr++;
  282.                                     if (*sptr!='[') break;
  283.  
  284.                                     sptr++;
  285.  
  286.                                     for(;;) switch (*sptr)
  287.                                        begin
  288.                                           case '0' :
  289.                                           case '1' :
  290.                                           case '2' :
  291.                                           case '3' :
  292.                                           case '4' :
  293.                                           case '5' :
  294.                                           case '6' :
  295.                                           case '7' :
  296.                                           case '8' :
  297.                                           case '9' :
  298.                                                      if (i>4)
  299.                                                         begin
  300.                                                            cprintf("Too complicated, line %d",line);
  301.                                                            exit(1);
  302.                                                         end
  303.                                                      ansi_digit[i] = atoi(sptr);
  304.                                                      do sptr++; while(isdigit(*sptr));
  305.                                                      i++;
  306.                                                      break;
  307.  
  308.                                           case ';' : sptr++;
  309.                                                      break;
  310.  
  311.                                           case 'k' : /* erase EOL           */
  312.                                                      command(0x07);
  313.                                                      sptr++;
  314.                                                      goto ansi_done;
  315.  
  316.                                           case 'A' : /* go up               */
  317.                                                      command(0x03);
  318.                                                      sptr++;
  319.                                                      goto ansi_done;
  320.  
  321.                                           case 'B' : /* go down             */
  322.                                                      command(0x04);
  323.                                                      sptr++;
  324.                                                      goto ansi_done;
  325.  
  326.                                           case 'C' : /* go right            */
  327.                                                      command(0x06);
  328.                                                      sptr++;
  329.                                                      goto ansi_done;
  330.  
  331.                                           case 'D' : /* go left             */
  332.                                                      command(0x05);
  333.                                                      sptr++;
  334.                                                      goto ansi_done;
  335.  
  336.                                           case 'J' : /* clear EOS           */
  337.                                                      putc( 0x0c, dest );
  338.                                                      sptr++;
  339.                                                      goto ansi_done;
  340.  
  341.                                           case 'm' : /* color               */
  342.                                                      color();
  343.                                                      sptr++;
  344.                                                      goto ansi_done;
  345.  
  346.                                           case 'f' : /* set cursor position */
  347.                                           case 'H' : /* set cursor position */
  348.                                                      if (ansi_digit[0]<0)
  349.                                                         ansi_digit[0] = 0;
  350.                                                      if (ansi_digit[1]<0)
  351.                                                         ansi_digit[1] = 0;
  352.                                                      putc(0x16, dest);
  353.                                                      putc(0x08, dest);
  354.                                                      putc(ansi_digit[0],dest);
  355.                                                      putc(ansi_digit[1],dest);
  356.                                                      sptr++;
  357.                                                      goto ansi_done;
  358.  
  359.                       case 's' : /* save cursor position */
  360.                              sptr++;
  361.                              sptr[0] = '\0';
  362.                                                      goto ansi_done;
  363.                       case 'u' : /* restore cursor position */
  364.                              sptr++;
  365.                                                      goto ansi_done;
  366.  
  367.                                           default  : /* we can't do this    */
  368.                                                      cprintf("Unknown ANSI command, line %d\n",line);
  369.                                                      exit(1);
  370.  
  371.  
  372.                                        end /* switch */
  373.  
  374.                                     break;
  375.  
  376.                       end /* switch */
  377. ansi_done:        ;
  378.                   
  379.  
  380.                end
  381. nxt:        ;
  382.       
  383.          end
  384.  
  385. done:
  386.       fclose(source);
  387.       fclose(dest);
  388.  
  389.    end /* main */
  390.  
  391.  
  392.  
  393.  
  394.  
  395. /* END OF FILE: make file name */
  396.  
  397.